home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1989 …il & Dave's Excellent CD / Excellent CD HFS.raw / Moof / Goodies / MPW Goodies / Interfaces / PInterfaces / Script.p < prev    next >
Encoding:
Text File  |  1988-11-30  |  27.1 KB  |  807 lines  |  [TEXT/MPS ]
  1. {
  2. Created: Saturday, October 15, 1988 at 6:30 AM
  3.     Script.p
  4.     Pascal Interface to the Macintosh Libraries
  5.  
  6.     Copyright Apple Computer, Inc.  1986-1988
  7.     All rights reserved
  8. }
  9.  
  10.  
  11. {$IFC UNDEFINED UsingIncludes}
  12. {$SETC UsingIncludes := 0}
  13. {$ENDC}
  14.  
  15. {$IFC NOT UsingIncludes}
  16.     UNIT Script;
  17.     INTERFACE
  18. {$ENDC}
  19.  
  20. {$IFC UNDEFINED UsingScript}
  21. {$SETC UsingScript := 1}
  22.  
  23. {$I+}
  24. {$SETC ScriptIncludes := UsingIncludes}
  25. {$SETC UsingIncludes := 1}
  26. {$IFC UNDEFINED UsingTypes}
  27. {$I $$Shell(PInterfaces)Types.p}
  28. {$ENDC}
  29. {$IFC UNDEFINED UsingPackages}
  30. {$I $$Shell(PInterfaces)Packages.p}
  31. {$ENDC}
  32. {$SETC UsingIncludes := ScriptIncludes}
  33.  
  34. CONST
  35.  
  36. { Note that the version number is divided into two bytes:  The high byte is
  37. bumped when the changes make the next version incompatible with previous
  38. versions.  If compatability is maintained, the low byte is bumped. }
  39.  
  40. smgrVers = $0210;                                   {current version number.}
  41.  
  42. { Script Interface System Numbers }
  43.  
  44. smRoman = 0;                                        {Font script is Roman.}
  45. smJapanese = 1;                                     {Font script is Japanese.}
  46. smChinese = 2;                                      {Font script is Chinese.}
  47. smKorean = 3;                                       {Font script is Korean.}
  48. smArabic = 4;                                       {Font script is Arabic.}
  49. smHebrew = 5;                                       {Font script is Hebrew.}
  50. smGreek = 6;                                        {Font script is Greek.}
  51. smRussian = 7;                                      {Font script is Russian.}
  52. smRSymbol = 8;                                      {Font script is Right-left symbol.}
  53. smDevanagari = 9;                                   {Font script is Devanagari.}
  54. smGurmukhi = 10;                                    {Font script is Gurmukhi.}
  55. smGujarati = 11;                                    {Font script is Gujarati.}
  56. smOriya = 12;                                       {Font script is Oriya.}
  57. smBengali = 13;                                     {Font script is Bengali.}
  58. smTamil = 14;                                       {Font script is Tamil.}
  59. smTelugu = 15;                                      {Font script is Telugu.}
  60. smKannada = 16;                                     {Font script is Kannada.}
  61. smMalayalam = 17;                                   {Font script is Malayalam.}
  62. smSinhalese = 18;                                   {Font script is Sinhalese.}
  63. smBurmese = 19;                                     {Font script is Burmese.}
  64. smKhmer = 20;                                       {Font script is Khmer.}
  65. smThai = 21;                                        {Font script is Thai.}
  66. smLaotian = 22;                                     {Font script is Laotian.}
  67. smGeorgian = 23;                                    {Font script is Georgian.}
  68. smArmenian = 24;                                    {Font script is Armenian.}
  69. smMaldivian = 25;                                   {Font script is Maldivian.}
  70. smTibetan = 26;                                     {Font script is Tibetan.}
  71. smMongolian = 27;                                   {Font script is Mongolian.}
  72. smAmharic = 28;                                     {Font script is Amharic.}
  73. smSlavic = 29;                                      {Font script is Slavic.}
  74. smVietnamese = 30;                                  {Font script is Vietnamese.}
  75. smSindhi = 31;                                      {Font script is Sindhi.}
  76. smUninterp = 32;                                    {Font script is uninterpreted symbols.}
  77.  
  78. { Language Codes }
  79.  
  80. langEnglish = 0;
  81. langFrench = 1;
  82. langGerman = 2;
  83. langItalian = 3;
  84. langDutch = 4;
  85. langSwedish = 5;
  86. langSpanish = 6;
  87. langDanish = 7;
  88. langPortugese = 8;
  89. langNorwegian = 9;
  90. langHebrew = 10;
  91. langJapanese = 11;
  92. langArabic = 12;
  93. langFinnish = 13;
  94. langGreek = 14;
  95. langIcelandic = 15;
  96. langMalta = 16;
  97. langTurkish = 17;
  98. langYugoslavian = 18;
  99. langChinese = 19;
  100. langUrdu = 20;
  101. langHindi = 21;
  102. langThai = 22;
  103.  
  104. { Calendar Codes }
  105.  
  106. calGregorian = 0;
  107. calArabicCivil = 1;
  108. calArabicLunar = 2;
  109. calJapanese = 3;
  110. calJewish = 4;
  111. calCoptic = 5;
  112.  
  113. { Integer Format Codes }
  114.  
  115. intWestern = 0;
  116. intArabic = 1;
  117. intRoman = 2;
  118. intJapanese = 3;
  119. intEuropean = 4;
  120. intOutputMask = $8000;
  121.  
  122. { CharByte byte types }
  123.  
  124. smSingleByte = 0;
  125. smFirstByte = -1;
  126. smLastByte = 1;
  127. smMiddleByte = 2;
  128.  
  129. { CharType field masks }
  130.  
  131. smcTypeMask = $000F;
  132. smcReserved = $00F0;
  133. smcClassMask = $0F00;
  134. smcReserved12 = $1000;
  135. smcRightMask = $2000;
  136. smcUpperMask = $4000;
  137. smcDoubleMask = $8000;
  138.  
  139. { CharType character types }
  140.  
  141. smCharPunct = 0;
  142. smCharAscii = 1;
  143. smCharEuro = 7;
  144.  
  145. { CharType punctuation types }
  146.  
  147. smPunctNormal = $0000;
  148. smPunctNumber = $0100;
  149. smPunctSymbol = $0200;
  150. smPunctBlank = $0300;
  151.  
  152. { CharType directions }
  153.  
  154. smCharLeft = $0000;
  155. smCharRight = $2000;
  156.  
  157. { CharType case modifers }
  158.  
  159. smCharLower = $0000;
  160. smCharUpper = $4000;
  161.  
  162. { CharType character size modifiers (1 or multiple bytes). }
  163.  
  164. smChar1byte = $0000;
  165. smChar2byte = $8000;
  166.  
  167. { Char2Pixel directions }
  168.  
  169. smLeftCaret = 0;                                    {Place caret for left block.}
  170. smRightCaret = -1;                                  {Place caret for right block.}
  171. smHilite = 1;                                       {Direction is TESysJust.}
  172.  
  173. { Transliterate target types }
  174.  
  175. smTransAscii = 0;
  176. smTransNative = 1;
  177. smTransCase = $FF;
  178.  
  179. { Transliterate target modifiers }
  180.  
  181. smTransLower = $4000;
  182. smTransUpper = $8000;
  183.  
  184. { Transliterate source masks }
  185.  
  186. smMaskAscii = $0001;
  187. smMaskNative = $0002;
  188.  
  189. { Result values from GetEnvirons, SetEnvirons, GetScript and SetScript calls. }
  190.  
  191. smNotInstalled = 0;                                 {routine not available in script}
  192. smBadVerb = -1;                                     {Bad verb passed to a routine.}
  193. smBadScript = -2;                                   {Bad script code passed to a routine.}
  194.  
  195. { GetEnvirons and SetEnvirons verbs }
  196.  
  197. smVersion = 0;                                      {Environment version number.}
  198. smMunged = 2;                                       {Globals change count.}
  199. smEnabled = 4;                                      {Environment enabled flag.}
  200. smBidirect = 6;                                     {At least on bidirect script.}
  201. smFontForce = 8;                                    {Force font flag.}
  202. smIntlForce = 10;                                   {Force intl flag.}
  203. smForced = 12;                                      {script forced to system script.}
  204. smDefault = 14;                                     {script defaulted to Roman script.}
  205. smPrint = 16;                                       {Printer action routine.}
  206. smSysScript = 18;                                   {System script.}
  207. smLastScript = 20;                                  {Last keyboard script.}
  208. smKeyScript = 22;                                   {Keyboard script.}
  209. smSysRef = 24;                                      {System folder refNum.}
  210. smKeyCache = 26;                                    {Keyboard table cache pointer.}
  211. smKeySwap = 28;                                     {Swapping table pointer.}
  212. smGenFlags = 30;                                    {General flags long}
  213. smOverride = 32;                                    {Script override flags.}
  214. smCharPortion = 34;                                 {Ch vs SpExtra proportion}
  215. smLastEVerb = smCharPortion;                        {Last environment verb.}
  216.  
  217. { GetScript and SetScript verbs.
  218. Note: Verbs private to script systems are negative, while
  219. those general across script systems are non-negative. }
  220.  
  221. smScriptVersion = 0;                                {Script software version.}
  222. smScriptMunged = 2;                                 {Script entry changed count.}
  223. smScriptEnabled = 4;                                {Script enabled flag.}
  224. smScriptRight = 6;                                  {Right to left flag.}
  225. smScriptJust = 8;                                   {Justification flag.}
  226. smScriptRedraw = 10;                                {Word redraw flag.}
  227. smScriptSysFond = 12;                               {Preferred system font.}
  228. smScriptAppFond = 14;                               {Preferred Application font.}
  229. smScriptBundle = 16;                                {Beginning of dictionary verbs.}
  230. smScriptNumber = 16;                                {Script itl0 id from dictionary.}
  231. smScriptDate = 18;                                  {Script itl1 id from dictionary.}
  232. smScriptSort = 20;                                  {Script itl2 id from dictionary.}
  233. smScriptFlags = 22;                                 {flags word.}
  234. smScriptToken = 24;                                 {Script itl3 id, from dictionary.}
  235. smScriptRsvd3 = 26;                                 {reserved.}
  236. smScriptLang = 28;                                  {Current language for script.}
  237. smScriptNumDate = 30;                               {Script Number/Date formats.}
  238. smScriptKeys = 32;                                  {Script KEYC id from dictionary.}
  239. smScriptIcon = 34;                                  {Script SICN id from dictionary.}
  240. smScriptPrint = 36;                                 {Script printer action routine.}
  241. smScriptTrap = 38;                                  {Trap entry pointer.}
  242. smScriptCreator = 40;                               {Script file creator.}
  243. smScriptFile = 42;                                  {Script file name.}
  244. smScriptName = 44;                                  {Script name.}
  245. smLastSVerb = smScriptName;                         {Last script verb.}
  246.  
  247. { Bits in the smScriptFlags word
  248. (bits above 7 are non-static) }
  249.  
  250. smsfIntellCP = 0;                                   {script has intellegent cut & paste}
  251. smsfSingByte = 1;                                   {script has only single bytes}
  252. smsfNatCase = 2;                                    {native chars have upper & lower case}
  253. smsfContext = 3;                                    {contextual script (e.g. AIS-based)}
  254. smsfNoForceFont = 4;                                {Will not force characters.}
  255. smsfB0Digits = 5;                                   {Has alternate digits at B0-B9.}
  256. smsfForms = 13;                                     {Uses contextual forms for letters.}
  257. smsfLigatures = 14;                                 {Uses contextual ligatures.}
  258. smsfReverse = 15;                                   {Reverses native text, right-left.}
  259.  
  260. { Bits in the smGenFlags long.
  261. First byte is set from itlc flags byte. }
  262.  
  263. smfShowIcon = 31;                                   {Show icon even if only one script.}
  264. smfDualCaret = 30;                                  {Use dual caret for mixed direction text.}
  265.  
  266. { Roman script constants }
  267.  
  268. romanVers = $0101;                                  {version number}
  269. romanSysFond = $3FFF;                               {system font id number}
  270. romanAppFond = 3;                                   {application font id number.}
  271. romanFlags = $0007;                                 {roman settings}
  272.  
  273. { Script Manager font equates. }
  274.  
  275. smFondStart = $4000;                                {start from 16K.}
  276. smFondEnd = $C000;                                  {past end of range at 48K.}
  277.  
  278. { Character Set Extensions }
  279.  
  280. diaeresisUprY = $D9;
  281. fraction = $DA;
  282. intlCurrency = $DB;
  283. leftSingGuillemet = $DC;
  284. rightSingGuillemet = $DD;
  285. fiLigature = $DE;
  286. flLigature = $DF;
  287. dblDagger = $E0;
  288. centeredDot = $E1;
  289. baseSingQuote = $E2;
  290. baseDblQuote = $E3;
  291. perThousand = $E4;
  292. circumflexUprA = $E5;
  293. circumflexUprE = $E6;
  294. acuteUprA = $E7;
  295. diaeresisUprE = $E8;
  296. graveUprE = $E9;
  297. acuteUprI = $EA;
  298. circumflexUprI = $EB;
  299. diaeresisUprI = $EC;
  300. graveUprI = $ED;
  301. acuteUprO = $EE;
  302. circumflexUprO = $EF;
  303. appleLogo = $F0;
  304. graveUprO = $F1;
  305. acuteUprU = $F2;
  306. circumflexUprU = $F3;
  307. graveUprU = $F4;
  308. dotlessLwrI = $F5;
  309. circumflex = $F6;
  310. tilde = $F7;
  311. macron = $F8;
  312. breve = $F9;
  313. overDot = $FA;
  314. ring = $FB;
  315. cedilla = $FC;
  316. doubleAcute = $FD;
  317. ogonek = $FE;
  318. hachek = $FF;
  319.  
  320. { String2Date status values }
  321.  
  322. fatalDateTime = $8000;
  323. longDateFound = 1;
  324. leftOverChars = 2;
  325. sepNotIntlSep = 4;
  326. fieldOrderNotIntl = 8;
  327. extraneousStrings = 16;
  328. tooManySeps = 32;
  329. sepNotConsistent = 64;
  330. tokenErr = $8100;
  331. cantReadUtilities = $8200;
  332. dateTimeNotFound = $8400;
  333. dateTimeInvalid = $8800;
  334.  
  335. { TokenType values }
  336.  
  337. tokenIntl = 4;                                      {the itl resource number of the tokenizer}
  338. tokenEmpty = -1;
  339. tokenUnknown = 0;
  340. tokenWhite = 1;
  341. tokenLeftLit = 2;
  342. tokenRightLit = 3;
  343. tokenAlpha = 4;
  344. tokenNumeric = 5;
  345. tokenNewLine = 6;
  346. tokenLeftComment = 7;
  347. tokenRightComment = 8;
  348. tokenLiteral = 9;
  349. tokenEscape = 10;
  350. tokenAltNum = 11;
  351. tokenRealNum = 12;
  352. tokenAltReal = 13;
  353. tokenReserve1 = 14;
  354. tokenReserve2 = 15;
  355. tokenLeftParen = 16;
  356. tokenRightParen = 17;
  357. tokenLeftBracket = 18;
  358. tokenRightBracket = 19;
  359. tokenLeftCurly = 20;
  360. tokenRightCurly = 21;
  361. tokenLeftEnclose = 22;
  362. tokenRightEnclose = 23;
  363. tokenPlus = 24;
  364. tokenMinus = 25;
  365. tokenAsterisk = 26;
  366. tokenDivide = 27;
  367. tokenPlusMinus = 28;
  368. tokenSlash = 29;
  369. tokenBackSlash = 30;
  370. tokenLess = 31;
  371. tokenGreat = 32;
  372. tokenEqual = 33;
  373. tokenLessEqual2 = 34;
  374. tokenLessEqual1 = 35;
  375. tokenGreatEqual2 = 36;
  376. tokenGreatEqual1 = 37;
  377. token2Equal = 38;
  378. tokenColonEqual = 39;
  379. tokenNotEqual = 40;
  380. tokenLessGreat = 41;
  381. tokenExclamEqual = 42;
  382. tokenExclam = 43;
  383. tokenTilda = 44;
  384. tokenComma = 45;
  385. tokenPeriod = 46;
  386. tokenLeft2Quote = 47;
  387. tokenRight2Quote = 48;
  388. tokenLeft1Quote = 49;
  389. tokenRight1Quote = 50;
  390. token2Quote = 51;
  391. token1Quote = 52;
  392. tokenSemicolon = 53;
  393. tokenPercent = 54;
  394. tokenCarat = 55;
  395. tokenUnderline = 56;
  396. tokenAmpersand = 57;
  397. tokenAtSign = 58;
  398. tokenBar = 59;
  399. tokenQuestion = 60;
  400. tokenPi = 61;
  401. tokenRoot = 62;
  402. tokenSigma = 63;
  403. tokenIntegral = 64;
  404. tokenMicro = 65;
  405. tokenCapPi = 66;
  406. tokenInfinity = 67;
  407. tokenColon = 68;
  408. tokenHash = 69;
  409. tokenDollar = 70;
  410. tokenNoBreakSpace = 71;
  411. tokenNil = 127;
  412. delimPad = -2;
  413.  
  414. { the NumberParts indeces }
  415.  
  416. tokLeftQuote = 1;
  417. tokRightQuote = 2;
  418. tokLeadPlacer = 3;
  419. tokLeader = 4;
  420. tokNonLeader = 5;
  421. tokZeroLead = 6;
  422. tokPercent = 7;
  423. tokPlusSign = 8;
  424. tokMinusSign = 9;
  425. tokThousands = 10;
  426. tokSeparator = 12;                                  {11 is a reserved field}
  427. tokEscape = 13;
  428. tokDecPoint = 14;
  429. tokEPlus = 15;
  430. tokEMinus = 16;
  431. tokMaxSymbols = 31;
  432. curNumberPartsVersion = 1;                          {current version of NumberParts record}
  433.  
  434. {  Date equates }
  435.  
  436. smallDateBit = 31;
  437. validDateFields = -1;
  438. maxDateField = 10;
  439. eraMask = $0001;
  440. yearMask = $0002;
  441. monthMask = $0004;
  442. dayMask = $0008;
  443. hourMask = $0010;
  444. minuteMask = $0020;
  445. secondMask = $0040;
  446. dayOfWeekMask = $0080;
  447. dayOfYearMask = $0100;
  448. weekOfYearMask = $0200;
  449. pmMask = $0400;
  450. dateStdMask = $007F;
  451. fVNumber = 0;                                       {first version of NumFormatString}
  452.  
  453.  
  454. TYPE
  455.  
  456. TokenResults = (tokenOK,tokenOverflow,stringOverflow,badDelim,badEnding,
  457.     crash);
  458.  
  459. LongDateField = (eraField,yearField,monthField,dayField,hourField,minuteField,
  460.     secondField,dayOfWeekField,dayOfYearField,weekOfYearField,pmField,res1Field,
  461.     res2Field,res3Field);
  462.  
  463. StyledLineBreakCode = (smBreakWord,smBreakChar,smBreakOverflow);
  464.  
  465. FormatClass = (fPositive,fNegative,fZero);
  466.  
  467. ToggleResults = (toggleUndefined,toggleOk,toggleBadField,toggleBadDelta,
  468.     toggleBadChar,toggleUnknown,toggleBadNum,toggleErr3,toggleErr4,toggleErr5);
  469.  
  470. FormatResultType = (fFormatOK,fBestGuess,fOutOfSynch,fSpuriousChars,fMissingDelimiter,
  471.     fExtraDecimal,fMissingLiteral,fExtraExp,fFormatOverflow,fFormStrIsNAN,
  472.     fBadPartsTable,fExtraPercent,fExtraSeparator,fEmptyFormatString);
  473.  
  474.  
  475. CharByteTable = PACKED ARRAY [0..255] OF SignedByte;
  476.  
  477. BreakTablePtr = ^BreakTable;
  478. BreakTable = RECORD
  479.     charTypes: ARRAY [0..255] OF SignedByte;
  480.     tripleLength: INTEGER;
  481.     triples: ARRAY [0..0] OF INTEGER;
  482.     END;
  483.  
  484. OffPair = RECORD
  485.     offFirst: INTEGER;
  486.     offSecond: INTEGER;
  487.     END;
  488.  
  489. OffsetTable = ARRAY [0..2] of OffPair;
  490.  
  491. ItlcRecord = RECORD
  492.     itlcSystem: INTEGER;                            {default system script.}
  493.     itlcReserved: INTEGER;                          {reserved}
  494.     itlcFontForce: SignedByte;                      {default font force flag}
  495.     itlcIntlForce: SignedByte;                      {default intl force flag.}
  496.     itlcOldKybd: SignedByte;                        {old keyboard}
  497.     itlcFlags: SignedByte;                          {general flags}
  498.     itlcReserved2: ARRAY [0..39] OF SignedByte;     {for future use}
  499.     END;
  500.  
  501. ItlbRecord = RECORD
  502.     itlbNumber: INTEGER;                            {ITL0 id number.}
  503.     itlbDate: INTEGER;                              {ITL1 id number.}
  504.     itlbSort: INTEGER;                              {ITL2 id number.}
  505.     itlbFlags: INTEGER;                             {Script flags}
  506.     itlbToken: INTEGER;                             {ITL4 id number.}
  507.     itlbReserved3: INTEGER;                         {reserved.}
  508.     itlbLang: INTEGER;                              {cur language for script }
  509.     itlbNumRep: SignedByte;                         {number representation code}
  510.     itlbDateRep: SignedByte;                        {date representation code }
  511.     itlbKeys: INTEGER;                              {KCHR id number.}
  512.     itlbIcon: INTEGER;                              {SICN id number.}
  513.     END;
  514.  
  515. MachineLocation = RECORD
  516.     latitude: Fract;
  517.     longitude: Fract;
  518.     CASE INTEGER OF
  519.       0:
  520.         (dlsDelta: SignedByte);                     {signed byte; daylight savings delta}
  521.       1:
  522.         (gmtDelta: LONGINT);                        {must mask - see documentation}
  523.     END;
  524.  
  525. String2DateStatus = INTEGER;
  526.  
  527. TokenType = INTEGER;
  528.  
  529. DelimType = ARRAY [0..1] OF TokenType;
  530.  
  531. CommentType = ARRAY [0..3] OF TokenType;
  532.  
  533. TokenRecPtr = ^TokenRec;
  534. TokenRec = RECORD
  535.     theToken: TokenType;
  536.     position: Ptr;                                  {pointer into original Source}
  537.     length: LONGINT;                                {length of text in original source}
  538.     stringPosition: StringPtr;                      {Pascal/C string copy of identifier}
  539.     END;
  540.  
  541. TokenBlockPtr = ^TokenBlock;
  542. TokenBlock = RECORD
  543.     source: Ptr;                                    {pointer to stream of characters}
  544.     sourceLength: LONGINT;                          {length of source stream}
  545.     tokenList: Ptr;                                 {pointer to array of tokens}
  546.     tokenLength: LONGINT;                           {maximum length of TokenList}
  547.     tokenCount: LONGINT;                            {number tokens generated by tokenizer}
  548.     stringList: Ptr;                                {pointer to stream of identifiers}
  549.     stringLength: LONGINT;                          {length of string list}
  550.     stringCount: LONGINT;                           {number of bytes currently used}
  551.     doString: BOOLEAN;                              {make strings & put into StringLIst}
  552.     doAppend: BOOLEAN;                              {append to TokenList rather than replace}
  553.     doAlphanumeric: BOOLEAN;                        {identifiers may include numeric}
  554.     doNest: BOOLEAN;                                {do comments nest?}
  555.     leftDelims: ARRAY [0..1] OF TokenType;
  556.     rightDelims: ARRAY [0..1] OF TokenType;
  557.     leftComment: ARRAY [0..3] OF TokenType;
  558.     rightComment: ARRAY [0..3] OF TokenType;
  559.     escapeCode: TokenType;                          {escape symbol code}
  560.     decimalCode: TokenType;
  561.     itlResource: Handle;                            {ptr to itl4 resource of current script}
  562.     reserved: ARRAY [0..7] OF LONGINT;              {must be zero!}
  563.     END;
  564.  
  565. UntokenTablePtr = ^UntokenTable;
  566. UntokenTableHandle = ^UntokenTablePtr;
  567. UntokenTable = RECORD
  568.     len: INTEGER;
  569.     lastToken: INTEGER;
  570.     index: ARRAY [0..255] OF INTEGER;               {index table; last = lastToken}
  571.     END;
  572.  
  573. DateCachePtr = ^DateCacheRecord;
  574. DateCacheRecord = PACKED RECORD
  575.     hidden: ARRAY [0..255] OF INTEGER;              {only for temporary use}
  576.     END;
  577.  
  578. LongDateTime = Comp;
  579.  
  580. LongDateCvt = RECORD
  581.     CASE INTEGER OF
  582.       0:
  583.         (c: Comp);
  584.       1:
  585.         (lHigh: LONGINT;
  586.         lLow: LONGINT);
  587.     END;
  588.  
  589. LongDateRec = RECORD
  590.     CASE INTEGER OF
  591.       0:
  592.         (era: INTEGER;
  593.         year: INTEGER;
  594.         month: INTEGER;
  595.         day: INTEGER;
  596.         hour: INTEGER;
  597.         minute: INTEGER;
  598.         second: INTEGER;
  599.         dayOfWeek: INTEGER;
  600.         dayOfYear: INTEGER;
  601.         weekOfYear: INTEGER;
  602.         pm: INTEGER;
  603.         res1: INTEGER;
  604.         res2: INTEGER;
  605.         res3: INTEGER);
  606.       1:
  607.         (list: ARRAY [0..13] OF INTEGER);           {Index by LongDateField!}
  608.       2:
  609.         (eraAlt: INTEGER;
  610.         oldDate: DateTimeRec);
  611.     END;
  612.  
  613. DateDelta = SignedByte;
  614.  
  615. TogglePB = RECORD
  616.     togFlags: LONGINT;                              {default $7E}
  617.     amChars: ResType;                               {from intl0}
  618.     pmChars: ResType;                               {from intl0}
  619.     reserved: ARRAY [0..3] OF LONGINT;
  620.     END;
  621.  
  622. FormatOrderPtr = ^FormatOrder;
  623. FormatOrder = ARRAY [0..0] OF INTEGER;
  624.  
  625. FormatStatus = INTEGER;
  626.  
  627. WideChar = RECORD
  628.     CASE BOOLEAN OF
  629.       TRUE:
  630.         (a: PACKED ARRAY [0..1] OF CHAR);           {0 is the high order character}
  631.       FALSE:
  632.         (b: INTEGER);
  633.     END;
  634.  
  635. WideCharArr = RECORD
  636.     size: INTEGER;
  637.     data: PACKED ARRAY [0..9] OF WideChar;
  638.     END;
  639.  
  640. NumFormatString = PACKED RECORD
  641.     fLength: Byte;
  642.     fVersion: Byte;
  643.     data: PACKED ARRAY [0..253] OF SignedByte;      {private data}
  644.     END;
  645.  
  646. Itl4Ptr = ^Itl4Rec;
  647. Itl4Handle = ^Itl4Ptr;
  648. Itl4Rec = RECORD
  649.     flags: INTEGER;
  650.     resourceType: LONGINT;
  651.     resourceNum: INTEGER;
  652.     version: INTEGER;
  653.     resHeader1: LONGINT;
  654.     resHeader2: LONGINT;
  655.     numTables: INTEGER;                             {one-based}
  656.     mapOffset: LONGINT;                             {offsets are from record start}
  657.     strOffset: LONGINT;
  658.     fetchOffset: LONGINT;
  659.     unTokenOffset: LONGINT;
  660.     defPartsOffset: LONGINT;
  661.     resOffset6: LONGINT;
  662.     resOffset7: LONGINT;
  663.     resOffset8: LONGINT;
  664.     END;
  665.  
  666. NumberPartsPtr = ^NumberParts;
  667. NumberParts = RECORD
  668.     version: INTEGER;
  669.     data: ARRAY [1..31] OF WideChar;                {index by [tokLeftQuote..tokMaxSymbols]}
  670.     pePlus: WideCharArr;
  671.     peMinus: WideCharArr;
  672.     peMinusPlus: WideCharArr;
  673.     altNumTable: WideCharArr;
  674.     reserved: PACKED ARRAY [0..19] OF CHAR;
  675.     END;
  676.  
  677. FVector = RECORD
  678.     start: INTEGER;
  679.     length: INTEGER;
  680.     END;
  681.  
  682. TripleInt = ARRAY [0..2] OF FVector;                { index by [fPositive..fZero] }
  683.  
  684. ScriptRunStatus = RECORD
  685.     script: SignedByte;
  686.     variant: SignedByte;
  687.     END;
  688.  
  689.  
  690.  
  691. FUNCTION FontScript: INTEGER;
  692.     INLINE $2F3C,$8200,$0000,$A8B5;
  693. FUNCTION IntlScript: INTEGER;
  694.     INLINE $2F3C,$8200,$0002,$A8B5;
  695. PROCEDURE KeyScript(code: INTEGER);
  696.     INLINE $2F3C,$8002,$0004,$A8B5;
  697. FUNCTION Font2Script(fontNumber: INTEGER): INTEGER;
  698.     INLINE $2F3C,$8202,$0006,$A8B5;
  699. FUNCTION GetEnvirons(verb: INTEGER): LONGINT;
  700.     INLINE $2F3C,$8402,$0008,$A8B5;
  701. FUNCTION SetEnvirons(verb: INTEGER;param: LONGINT): OSErr;
  702.     INLINE $2F3C,$8206,$000A,$A8B5;
  703. FUNCTION GetScript(script: INTEGER;verb: INTEGER): LONGINT;
  704.     INLINE $2F3C,$8404,$000C,$A8B5;
  705. FUNCTION SetScript(script: INTEGER;verb: INTEGER;param: LONGINT): OSErr;
  706.     INLINE $2F3C,$8208,$000E,$A8B5;
  707. FUNCTION CharByte(textBuf: Ptr;textOffset: INTEGER): INTEGER;
  708.     INLINE $2F3C,$8206,$0010,$A8B5;
  709. FUNCTION CharType(textBuf: Ptr;textOffset: INTEGER): INTEGER;
  710.     INLINE $2F3C,$8206,$0012,$A8B5;
  711. FUNCTION Pixel2Char(textBuf: Ptr;textLen: INTEGER;slop: INTEGER;pixelWidth: INTEGER;
  712.     VAR leftSide: BOOLEAN): INTEGER;
  713.     INLINE $2F3C,$820E,$0014,$A8B5;
  714. FUNCTION Char2Pixel(textBuf: Ptr;textLen: INTEGER;slop: INTEGER;offset: INTEGER;
  715.     direction: INTEGER): INTEGER;
  716.     INLINE $2F3C,$820C,$0016,$A8B5;
  717. FUNCTION Transliterate(srcHandle: Handle;dstHandle: Handle;target: INTEGER;
  718.     srcMask: LONGINT): OSErr;
  719.     INLINE $2F3C,$820E,$0018,$A8B5;
  720. PROCEDURE FindWord(textPtr: Ptr;textLength: INTEGER;offset: INTEGER;leftSide: BOOLEAN;
  721.     breaks: BreakTablePtr;VAR offsets: OffsetTable);
  722.     INLINE $2F3C,$8012,$001A,$A8B5;
  723. PROCEDURE HiliteText(textPtr: Ptr;textLength: INTEGER;firstOffset: INTEGER;
  724.     secondOffset: INTEGER;VAR offsets: OffsetTable);
  725.     INLINE $2F3C,$800E,$001C,$A8B5;
  726. PROCEDURE DrawJust(textPtr: Ptr;textLength: INTEGER;slop: INTEGER);
  727.     INLINE $2F3C,$8008,$001E,$A8B5;
  728. PROCEDURE MeasureJust(textPtr: Ptr;textLength: INTEGER;slop: INTEGER;charLocs: Ptr);
  729.     INLINE $2F3C,$800C,$0020,$A8B5;
  730. FUNCTION ParseTable(table: CharByteTable): BOOLEAN;
  731.     INLINE $2F3C,$8204,$0022,$A8B5;
  732. FUNCTION GetDefFontSize: INTEGER;
  733.     INLINE $3EB8,$0BA8,$6604,$3EBC,$000C;
  734. FUNCTION GetSysFont: INTEGER;
  735.     INLINE $3EB8,$0BA6;
  736. FUNCTION GetAppFont: INTEGER;
  737.     INLINE $3EB8,$0984;
  738. FUNCTION GetMBarHeight: INTEGER;
  739.     INLINE $3EB8,$0BAA;
  740. FUNCTION GetSysJust: INTEGER;
  741.     INLINE $3EB8,$0BAC;
  742. PROCEDURE SetSysJust(newJust: INTEGER);
  743.     INLINE $31DF,$0BAC;
  744. PROCEDURE ReadLocation(VAR loc: MachineLocation);
  745.     INLINE $205F,$203C,$000C,$00E4,$A051;
  746. PROCEDURE WriteLocation(loc: MachineLocation);
  747.     INLINE $205F,$203C,$000C,$00E4,$A052;
  748. PROCEDURE UprText(textPtr: Ptr;len: INTEGER);
  749.     INLINE $301F,$205F,$A054;
  750. PROCEDURE LwrText(textPtr: Ptr;len: INTEGER);
  751.     INLINE $301F,$205F,$A056;
  752. FUNCTION StyledLineBreak(textPtr: Ptr;textLen: LONGINT;textStart: LONGINT;
  753.     textEnd: LONGINT;flags: LONGINT;VAR textWidth: Fixed;VAR textOffset: LONGINT): StyledLineBreakCode;
  754.     INLINE $2F3C,$821C,$FFFE,$A8B5;
  755. PROCEDURE GetFormatOrder(ordering: FormatOrderPtr;firstFormat: INTEGER;
  756.     lastFormat: INTEGER;lineRight: BOOLEAN;rlDirProc: Ptr;dirParam: Ptr);
  757.     INLINE $2F3C,$8012,$FFFC,$A8B5;
  758. FUNCTION IntlTokenize(tokenParam: TokenBlockPtr): TokenResults;
  759.     INLINE $2F3C,$8204,$FFFA,$A8B5;
  760. FUNCTION InitDateCache(theCache: DateCachePtr): OSErr;
  761.     INLINE $2F3C,$8204,$FFF8,$A8B5;
  762. FUNCTION String2Date(textPtr: Ptr;textLen: LONGINT;theCache: DateCachePtr;
  763.     VAR lengthUsed: LONGINT;VAR dateTime: LongDateRec): String2DateStatus;
  764.     INLINE $2F3C,$8214,$FFF6,$A8B5;
  765. FUNCTION String2Time(textPtr: Ptr;textLen: LONGINT;theCache: DateCachePtr;
  766.     VAR lengthUsed: LONGINT;VAR dateTime: LongDateRec): String2DateStatus;
  767.     INLINE $2F3C,$8214,$FFF4,$A8B5;
  768. PROCEDURE LongDate2Secs(lDate: LongDateRec;VAR lSecs: LongDateTime);
  769.     INLINE $2F3C,$8008,$FFF2,$A8B5;
  770. PROCEDURE LongSecs2Date(VAR lSecs: LongDateTime;VAR lDate: LongDateRec);
  771.     INLINE $2F3C,$8008,$FFF0,$A8B5;
  772. FUNCTION ToggleDate(VAR lSecs: LongDateTime;field: LongDateField;delta: DateDelta;
  773.     ch: INTEGER;params: TogglePB): ToggleResults;
  774.     INLINE $2F3C,$820E,$FFEE,$A8B5;
  775. FUNCTION Str2Format(inString: Str255;partsTable: NumberParts;VAR outString: NumFormatString): FormatStatus;
  776.     INLINE $2F3C,$820C,$FFEC,$A8B5;
  777. FUNCTION Format2Str(myCanonical: NumFormatString;partsTable: NumberParts;
  778.     VAR outString: Str255;VAR positions: TripleInt): FormatStatus;
  779.     INLINE $2F3C,$8210,$FFEA,$A8B5;
  780. FUNCTION FormatX2Str(x: Extended;myCanonical: NumFormatString;partsTable: NumberParts;
  781.     VAR outString: Str255): FormatStatus;
  782.     INLINE $2F3C,$8210,$FFE8,$A8B5;
  783. FUNCTION FormatStr2X(source: Str255;myCanonical: NumFormatString;partsTable: NumberParts;
  784.     VAR x: Extended): FormatStatus;
  785.     INLINE $2F3C,$8210,$FFE6,$A8B5;
  786. FUNCTION PortionText(textPtr: Ptr;textLen: LONGINT): Fixed;
  787.     INLINE $2F3C,$8408,$0024,$A8B5;
  788. FUNCTION FindScriptRun(textPtr: Ptr;textLen: LONGINT;VAR lenUsed: LONGINT): ScriptRunStatus;
  789.     INLINE $2F3C,$820C,$0026,$A8B5;
  790. FUNCTION VisibleLength(textPtr: Ptr;textLen: LONGINT): LONGINT;
  791.     INLINE $2F3C,$8408,$0028,$A8B5;
  792. FUNCTION ValidDate(VAR vDate: LongDateRec;flags: LONGINT;VAR newSecs: LongDateTime): INTEGER;
  793.     INLINE $2F3C,$8204,$FFE4,$A8B5;
  794. PROCEDURE IULDateString(VAR dateTime: LongDateTime;longFlag: DateForm;VAR result: Str255;
  795.     intlParam: Handle);
  796.     INLINE $3F3C,$0014,$A9ED;
  797. PROCEDURE IULTimeString(VAR dateTime: LongDateTime;wantSeconds: BOOLEAN;
  798.     VAR result: Str255;intlParam: Handle);
  799.     INLINE $3F3C,$0016,$A9ED;
  800.  
  801. {$ENDC}    { UsingScript }
  802.  
  803. {$IFC NOT UsingIncludes}
  804.     END.
  805. {$ENDC}
  806.  
  807.